package rest.resources;

import java.util.ArrayList;
import java.util.Collection;

import org.orm.PersistentException;
import org.orm.PersistentTransaction;

import SOAPVO.PersonaSOAPVO;
import SOAPVO.PublicacionSOAPVO;

import com.google.gson.Gson;

import orm.Tcp_persona;

import javax.ws.rs.DELETE;
import javax.ws.rs.FormParam;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

/**
 * 
 * @author
 */
@Path("/publicacion")
public class PublicacionSOA {
	private static final int ROW_COUNT = 100;

	/**
	 * Este método sirve para ingresar una nueva publicación, segun el rut de la
	 * persona se busca la id de este
	 * 
	 * @param id , corresponde al id de la persona a la cual se le añade
	 *            unapublicación
	 * @param descripcion  , descripción de la nueva publicación
	 * @param monto, monto de la nueva publicación
	 * @return
	 * @throws PersistentException
	 */
	@POST
	@Path("/add")
	@Produces(MediaType.TEXT_PLAIN)
	public String add(@FormParam("pub_mon") String pub_mon,
			@FormParam("pub_des") String pub_des,
			@FormParam("pers_rut") String pers_rut) {

		PersistentTransaction t;
		String resultado = "";
		// orm.dao.Tcp_personaDAO lormTcp_personaDAO =
		// lDAOFactory.getTcp_personaDAO();
		// orm.Tcp_persona[] ormPersonas;

		if ((pub_mon == null) || (pub_mon.equals("")) || (pub_des == null)
				|| (pub_des.equals("")) || (pers_rut == null)
				|| (pers_rut.equals(""))) {

			resultado = "ERROR: Ingrese todos los datos (monto de publicación, descripción y rut de la persona)";

		}// si los datos vienen vacios

		else {

			try {
				t = orm.TallerdeSOAPersistentManager.instance().getSession()
						.beginTransaction();
				// Instancia factory
				orm.DAOFactory lDAOFactory = orm.DAOFactory.getDAOFactory();
				// Instancia DAO
				orm.dao.Tcp_publicacionDAO lormTcp_publicacionDAO = lDAOFactory
						.getTcp_publicacionDAO();
				// Instancia objeto orm (vo)
				orm.Tcp_publicacion lormTcp_publicacion = lormTcp_publicacionDAO
						.createTcp_publicacion();
				orm.Tcp_persona[] ormPersonas;

				ormPersonas = lDAOFactory.getTcp_personaDAO()
						.listTcp_personaByQuery("pers_rut='" + pers_rut + "'",
								null);
				int length2 = ormPersonas.length;

				if (length2 == 0) {

					resultado = "ERROR: No se ha encontrado registros del rut ingresado";
				}

				else {
					// Establece criterio
					orm.Tcp_personaCriteria tcp_personaCriteria = new orm.Tcp_personaCriteria();

					tcp_personaCriteria.pers_rut.eq(pers_rut);

					Tcp_persona lormpersonPersona = new Tcp_persona();
					lormpersonPersona = tcp_personaCriteria.uniqueTcp_persona();

					// else{
					int mon = Integer.parseInt(pub_mon);
					// Set objeto orm
					lormTcp_publicacion.setPub_monto(mon);
					lormTcp_publicacion.setPub_descripcion(pub_des);
					lormTcp_publicacion.setPub_id_persona(lormpersonPersona);

					lormTcp_publicacionDAO.save(lormTcp_publicacion);

					resultado = "Publicación ingresada correctamente.";

				}
				t.commit();

			} catch (PersistentException e1) {
				// TODO Auto-generated catch block
				// e.printStackTrace();
				resultado = "<FAIL>";
				e1.printStackTrace();
			}

		}
		// resultado = pub_des+" ha sido agregado(a)";
		return resultado;
	}

	/**
	 * Este método sirve para borrar una publicación según su id
	 * 
	 * @param id
	 *            de publicación
	 * @return
	 * @throws PersistentException
	 */
	@DELETE
	@Path("/delete/{id}")
	public String borrar(@PathParam("id") String id) {

		String message = "";
		PersistentTransaction t;
		int resultado = 1;

		// valida si los campos solicitados vienen vacios.
		if ((id == null) || (id.equals(""))) {

			message = "debe ingresar la publicaci�n a borrar";
			resultado = 0;
		}
		// si no vienen vacios.
		else {
			// valida el largo del cuerpo del rut.

			try {

				t = orm.TallerdeSOAPersistentManager.instance().getSession()
						.beginTransaction();

				orm.DAOFactory lDAOFactory = orm.DAOFactory.getDAOFactory();
				orm.dao.Tcp_publicacionDAO lormTcp_publicacionDAO = lDAOFactory
						.getTcp_publicacionDAO();

				orm.Tcp_publicacion[] ormPublicacion;
				// busqueda del rut en la BD
				ormPublicacion = lDAOFactory
						.getTcp_publicacionDAO()
						.listTcp_publicacionByQuery("pub_id='" + id + "'", null);
				int length2 = ormPublicacion.length;
				// si no se encuentran registros para el rut.
				if (length2 == 0) {

					message = "ERROR: No se ha encontrado registros";
				}
				// si se encuentran registros para el rut
				else {
					orm.Tcp_publicacion lormTcp_publicacion = lormTcp_publicacionDAO
							.loadTcp_publicacionByQuery("pub_id=" + id, null);
					// se borra el registro.
					lormTcp_publicacionDAO.delete(lormTcp_publicacion);
					message = " ha sido eliminado(a) la publicacion";
				}

				t.commit();

			} catch (PersistentException e1) {
				// TODO Auto-generated catch block
				message = " error";
				// t.rollback();
				e1.printStackTrace();

			}

		}

		return message;
	}// fin borrar publicacion
	/**
	 * 
	 * @param id numero
	 * @param campo 0 cambia monto, 1 cambia descripcion 
	 * @param new_valor nuevo valor
	 * @return
	 */
	@PUT
	@Path("/update")
	public String update(@FormParam("id")  String id, 
			@FormParam("campo") int campo, 
			@FormParam("nuevo_valor") String new_valor) {

		PersistentTransaction t;
		String message = "";
		int length2 = 0;

		// valida que los campos solicitados no vengan vacios.
		if ((id == null) || (id.equals("")) || (new_valor.equals(""))
				|| (new_valor == null)) {

			message = "ERROR: Existen campos vacíos";

		}
		// si no vienen vacios se inicia el proceso.
		else {

			try {
				t = orm.TallerdeSOAPersistentManager.instance().getSession()
						.beginTransaction();
				orm.DAOFactory lDAOFactory = orm.DAOFactory.getDAOFactory();
				orm.dao.Tcp_publicacionDAO lormTcp_publicacionDAO = lDAOFactory
						.getTcp_publicacionDAO();
				// se busca el registro segun su rut.
				orm.Tcp_publicacion[] ormTcp_publicacion = lDAOFactory
						.getTcp_publicacionDAO().listTcp_publicacionByQuery(
								"pub_id='" + id + "'", null);
				int length = Math.min(ormTcp_publicacion.length, ROW_COUNT);
				// si se encuentra registro se procede a actualizar el nombre
				if (length >= 1) {
					orm.Tcp_publicacion lormTcp_publicacion = lormTcp_publicacionDAO
							.loadTcp_publicacionByQuery("pub_id='" + id + "'",
									null);
					if (campo == 0) {
						int valor = Integer.parseInt(new_valor);
						lormTcp_publicacion.setPub_monto(valor);
						lormTcp_publicacionDAO.save(lormTcp_publicacion);
						message = "El monto de publicación ha sido actualizado";
					}
					if (campo == 1) {
						lormTcp_publicacion.setPub_descripcion(new_valor);
						lormTcp_publicacionDAO.save(lormTcp_publicacion);
						message = "La descripción de la publicación ha sido actualizada";
					}
				}
				// si no encuentra segun el rut se produce la busqueda segun
				// nombre.
				else {
					message = "No se encontraron registros";
				}
				t.commit();
			} catch (PersistentException e1) {
				// t.rollback();
				message = "error";
				e1.printStackTrace();
			}
		}
		return message;
	}// fin método update

	/**
	 * Este método sirve para buscar una publicación segpun su id
	 * 
	 * @param id
	 * @return
	 * @throws PersistentException
	 */
	@GET
	@Path("/find/{buscar}")
	@Produces(MediaType.TEXT_PLAIN)
	public String find(@PathParam("buscar")  String buscar) {

		String message;

		if ((buscar == null) || (buscar.equals(""))) {

			message = "debe ingresar monto, descripcion o id de la publicación a buscar";

		}

		orm.DAOFactory lDAOFactory = orm.DAOFactory.getDAOFactory();

		orm.dao.Tcp_publicacionDAO lormTcp_publicacionDAO = lDAOFactory
				.getTcp_publicacionDAO();
		orm.Tcp_publicacion lormTcp_publicacion;
		try {
			lormTcp_publicacion = lormTcp_publicacionDAO
					.loadTcp_publicacionByQuery("pub_id='" + buscar + "'", null);
			String descrip = lormTcp_publicacion.getPub_descripcion();
			int monto = lormTcp_publicacion.getPub_monto();
			message = "Publicacion encontrada, monto \n" + monto
					+ "\n y su descripcción es: \n" + descrip;

		} catch (PersistentException e) {
			message = "Error";
			e.printStackTrace();
		}

		return message;
	}

	/**
	 * Método que realiza una busqueda de todas las publicaciones existentes.
	 * 
	 * @return json almacena todos los registros encontrados
	 */
	@GET
	@Path("/findall/{buscar}")
	@Produces(MediaType.TEXT_PLAIN)
	public static String findall(String buscar) {
		String json = null;
		int length2 = 0;
		int length3 = 0;
		orm.DAOFactory lDAOFactory = orm.DAOFactory.getDAOFactory();
		// Collection<orm.Persona> ormPersonas =
		// Arrays.asList(lDAOFactory.getPersonaDAO().listPersonaByQuery(null,
		// null));
		Collection<PublicacionSOAPVO> colecionPublicacionSOAPVO = new ArrayList<PublicacionSOAPVO>();

		orm.Tcp_publicacion[] ormPublicacion;
		try {

			if ((buscar == null) || (buscar.equals(""))) {// si no se ingresa
															// ningun filtro por
															// el cual buscar

				ormPublicacion = lDAOFactory.getTcp_publicacionDAO()
						.listTcp_publicacionByQuery(null, null);
				// busqueda de todos los registros existentes

			}

			else {// si se ingresa un filtro por el cual buscar

				ormPublicacion = lDAOFactory.getTcp_publicacionDAO()
						.listTcp_publicacionByQuery(
								"pub_monto='" + buscar + "'", null);
				// primera busqueda por defecto, segun el rut
				length2 = ormPublicacion.length;

				if (length2 == 0) {// si no se encuentran datos coincidentes con
									// el rut

					ormPublicacion = lDAOFactory.getTcp_publicacionDAO()
							.listTcp_publicacionByQuery(
									"pub_descripcion='" + buscar + "'", null);
					// segunda busqeuda por nombre
					length3 = ormPublicacion.length;
				}

				if (length2 == 0 && length3 == 0) {// si no se han encontrado
													// coincidencias ni por
													// nombre ni por rut

					ormPublicacion = lDAOFactory.getTcp_publicacionDAO()
							.listTcp_publicacionByQuery(
									"pub_id='" + buscar + "'", null);
					// tercera busqueda por identidad
				}

			}// fin busqueda segun filtro

			int length = ormPublicacion.length;
			if (length == 0) {// si no se encontraron registros
				json = "No se ha encontrado ningun registro";
			}
			else {// si se encontraron registros
				for (int i = 0; i < length; i++) {
					System.out.println(ormPublicacion[i].getPub_monto());
					PublicacionSOAPVO objeto = PublicacionSOAPVO
							.crearPublicacionSOAPVO(ormPublicacion[i]);
					colecionPublicacionSOAPVO.add(objeto);
				}// fin guardando resultados
				Gson gson = new Gson();
				json = gson.toJson(colecionPublicacionSOAPVO);
			}
		} catch (PersistentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

		return json;

	}
}
